home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / FromTheMag / XAMPP 1.4.14 / xampp-win32-1.4.14-installer.exe / xampp / php / pear / MDB / metabase_wrapper.php < prev    next >
PHP Script  |  2004-03-24  |  48KB  |  1,626 lines
  1. <?php
  2. // +----------------------------------------------------------------------+
  3. // | PHP Version 4                                                        |
  4. // +----------------------------------------------------------------------+
  5. // | Copyright (c) 1998-2004 Manuel Lemos, Tomas V.V.Cox,                 |
  6. // | Stig. S. Bakken, Lukas Smith                                         |
  7. // | All rights reserved.                                                 |
  8. // +----------------------------------------------------------------------+
  9. // | MDB is a merge of PEAR DB and Metabases that provides a unified DB   |
  10. // | API as well as database abstraction for PHP applications.            |
  11. // | This LICENSE is in the BSD license style.                            |
  12. // |                                                                      |
  13. // | Redistribution and use in source and binary forms, with or without   |
  14. // | modification, are permitted provided that the following conditions   |
  15. // | are met:                                                             |
  16. // |                                                                      |
  17. // | Redistributions of source code must retain the above copyright       |
  18. // | notice, this list of conditions and the following disclaimer.        |
  19. // |                                                                      |
  20. // | Redistributions in binary form must reproduce the above copyright    |
  21. // | notice, this list of conditions and the following disclaimer in the  |
  22. // | documentation and/or other materials provided with the distribution. |
  23. // |                                                                      |
  24. // | Neither the name of Manuel Lemos, Tomas V.V.Cox, Stig. S. Bakken,    |
  25. // | Lukas Smith nor the names of his contributors may be used to endorse |
  26. // | or promote products derived from this software without specific prior|
  27. // | written permission.                                                  |
  28. // |                                                                      |
  29. // | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS  |
  30. // | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT    |
  31. // | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS    |
  32. // | FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE      |
  33. // | REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,          |
  34. // | INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
  35. // | BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS|
  36. // |  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED  |
  37. // | AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT          |
  38. // | LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY|
  39. // | WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE          |
  40. // | POSSIBILITY OF SUCH DAMAGE.                                          |
  41. // +----------------------------------------------------------------------+
  42. // | Author: Lukas Smith <smith@backendmedia.com>                         |
  43. // +----------------------------------------------------------------------+
  44. //
  45. // $Id: metabase_wrapper.php,v 1.50.4.1 2004/01/08 13:43:02 lsmith Exp $
  46. //
  47.  
  48. MDB::loadFile('Date');
  49.  
  50. /**
  51.  * Wrapper that makes MDB behave like Metabase
  52.  *
  53.  * @package MDB
  54.  * @category Database
  55.  * @author  Lukas Smith <smith@backendmedia.com>
  56.  */
  57.  
  58. $lob_error = '';
  59.  
  60. function MetabaseSetupDatabase($arguments, &$database)
  61. {
  62.     _convertArguments($arguments, $dsninfo, $options);
  63.     $db =& MDB::connect($dsninfo, $options);
  64.  
  65.     if (MDB::isError($db) || !is_object($db)) {
  66.         $database = 0;
  67.         return($db->getMessage());
  68.     }
  69.     $database = $db->database;
  70.     return('');
  71. }
  72.  
  73. function MetabaseSetupDatabaseObject($arguments, &$db)
  74. {
  75.     _convertArguments($arguments, $dsninfo, $options);
  76.     $db =& MDB::connect($dsninfo, $options);
  77.  
  78.     if (MDB::isError($db) || !is_object($db)) {
  79.         return($db->getMessage());
  80.     }
  81.     return('');
  82. }
  83.  
  84. function _convertArguments($arguments, &$dsninfo, &$options)
  85. {
  86.     if (isset($arguments['Type'])) {
  87.         $dsninfo['phptype'] = $arguments['Type'];
  88.     }
  89.     if (isset($arguments['User'])) {
  90.         $dsninfo['username'] = $arguments['User'];
  91.     }
  92.     if(isset($arguments['Password'])) {
  93.         $dsninfo['password'] = $arguments['Password'];
  94.     }
  95.     if(isset($arguments['Host'])) {
  96.         $dsninfo['hostspec'] = $arguments['Host'];
  97.     }
  98.     if(isset($arguments['Options']['Port'])) {
  99.        $dsninfo['port'] = $arguments['Options']['Port'];
  100.        unset($arguments['Options']['Port']);
  101.     }
  102.  
  103.     if (isset($arguments['Persistent'])) {
  104.         $options['persistent'] = TRUE;
  105.     }
  106.     if(isset($arguments['Debug'])) {
  107.         $options['debug'] = $arguments['Debug'];
  108.     }
  109.     if(isset($arguments['DecimalPlaces'])) {
  110.         $options['decimal_places'] = $arguments['DecimalPlaces'];
  111.     }
  112.     if(isset($arguments['LOBBufferLength'])) {
  113.         $options['LOBbufferlength'] = $arguments['LOBBufferLength'];
  114.     }
  115.     if(isset($arguments['LogLineBreak'])) {
  116.         $options['loglinebreak'] = $arguments['LogLineBreak'];
  117.     }
  118.  
  119.     $options['seqname_format'] = '_sequence_%s';
  120.     if(isset($arguments['Options']) && is_array($arguments['Options'])) {
  121.        $options = array_merge($options, $arguments['Options']);
  122.     }
  123. }
  124.  
  125. function MetabaseCloseSetup($database)
  126. {
  127.     global $_MDB_databases;
  128.  
  129.     $_MDB_databases[$database]->disconnect();
  130.     unset($_MDB_databases[$database]);
  131. }
  132.  
  133. function MetabaseQuery($database, $query)
  134. {
  135.     global $_MDB_databases;
  136.     $result = $_MDB_databases[$database]->query($query);
  137.     if (MDB::isError($result)) {
  138.         $_MDB_databases[$database]->setError('Query', $result->getMessage());
  139.         return(0);
  140.     } else {
  141.         return($result);
  142.     }
  143. }
  144.  
  145. function MetabaseQueryField($database, $query, &$field, $type = 'text')
  146. {
  147.     global $_MDB_databases;
  148.     $result = $_MDB_databases[$database]->queryOne($query, $type);
  149.     if (MDB::isError($result)) {
  150.         $_MDB_databases[$database]->setError('QueryField', $result->getMessage());
  151.         return(0);
  152.     } else {
  153.         $field = $result;
  154.         return(1);
  155.     }
  156. }
  157.  
  158. function MetabaseQueryRow($database, $query, &$row, $types = '')
  159. {
  160.     global $_MDB_databases;
  161.     $result = $_MDB_databases[$database]->queryRow($query, $types);
  162.     if (MDB::isError($result)) {
  163.         $_MDB_databases[$database]->setError('QueryRow', $result->getMessage());
  164.         return(0);
  165.     } else {
  166.         $row = $result;
  167.         return(1);
  168.     }
  169. }
  170.  
  171. function MetabaseQueryColumn($database, $query, &$column, $type = 'text')
  172. {
  173.     global $_MDB_databases;
  174.     $result = $_MDB_databases[$database]->queryCol($query, $type);
  175.     if (MDB::isError($result)) {
  176.         $_MDB_databases[$database]->setError('QueryColumn', $result->getMessage());
  177.         return(0);
  178.     } else {
  179.         $column = $result;
  180.         return(1);
  181.     }
  182. }
  183.  
  184. function MetabaseQueryAll($database, $query, &$all, $types = '')
  185. {
  186.     global $_MDB_databases;
  187.     $result = $_MDB_databases[$database]->queryAll($query, $types);
  188.     if (MDB::isError($result)) {
  189.         $_MDB_databases[$database]->setError('QueryAll', $result->getMessage());
  190.         return(0);
  191.     } else {
  192.         $all = $result;
  193.         return(1);
  194.     }
  195. }
  196.  
  197. function MetabaseReplace($database, $table, &$fields)
  198. {
  199.     global $_MDB_databases;
  200.     for($count = count($fields), reset($fields), $field = 0;
  201.         $field < $count;
  202.         next($fields), $field++)
  203.     {
  204.         $name = key($fields);
  205.         if(!isset($fields[$name]['Type'])) {
  206.             $fields[$name]['Type'] = 'text';
  207.         }
  208.     }
  209.     $result = $_MDB_databases[$database]->replace($table, $fields);
  210.     if (MDB::isError($result)) {
  211.         $_MDB_databases[$database]->setError('Replace', $result->getMessage());
  212.         return(0);
  213.     } else {
  214.         return(1);
  215.     }
  216. }
  217.  
  218. function MetabasePrepareQuery($database, $query)
  219. {
  220.     global $_MDB_databases;
  221.     $result = $_MDB_databases[$database]->prepareQuery($query);
  222.     if (MDB::isError($result)) {
  223.         $_MDB_databases[$database]->setError('PrepareQuery', $result->getMessage());
  224.         return(0);
  225.     } else {
  226.         return($result);
  227.     }
  228. }
  229.  
  230. function MetabaseFreePreparedQuery($database, $prepared_query)
  231. {
  232.     global $_MDB_databases;
  233.     $result = $_MDB_databases[$database]->freePreparedQuery($prepared_query);
  234.     if (MDB::isError($result)) {
  235.         $_MDB_databases[$database]->setError('FreePreparedQuery', $result->getMessage());
  236.         return(0);
  237.     } else {
  238.         return($result);
  239.     }
  240. }
  241.  
  242. function MetabaseExecuteQuery($database, $prepared_query)
  243. {
  244.     global $_MDB_databases;
  245.     $result = $_MDB_databases[$database]->executeQuery($prepared_query);
  246.     if (MDB::isError($result)) {
  247.         $_MDB_databases[$database]->setError('ExecuteQuery', $result->getMessage());
  248.         return(0);
  249.     } else {
  250.         return($result);
  251.     }
  252. }
  253.  
  254. function MetabaseQuerySet($database, $prepared_query, $parameter, $type, $value, $is_null = 0, $field = '')
  255. {
  256.     global $_MDB_databases;
  257.     $result = $_MDB_databases[$database]->setParam($prepared_query, $parameter, $type, $value, $is_null, $field);
  258.     if (MDB::isError($result)) {
  259.         $_MDB_databases[$database]->setError('QuerySet', $result->getMessage());
  260.         return(0);
  261.     } else {
  262.         return(1);
  263.     }
  264. }
  265.  
  266. function MetabaseQuerySetNull($database, $prepared_query, $parameter, $type)
  267. {
  268.     global $_MDB_databases;
  269.     $result = $_MDB_databases[$database]->setParamNull($prepared_query, $parameter, $type);
  270.     if (MDB::isError($result)) {
  271.         $_MDB_databases[$database]->setError('QuerySetNull', $result->getMessage());
  272.         return(0);
  273.     } else {
  274.         return(1);
  275.     }
  276. }
  277.  
  278. function MetabaseQuerySetText($database, $prepared_query, $parameter, $value)
  279. {
  280.     global $_MDB_databases;
  281.     $result = $_MDB_databases[$database]->setParamText($prepared_query, $parameter, $value);
  282.     if (MDB::isError($result)) {
  283.         $_MDB_databases[$database]->setError('QuerySetText', $result->getMessage());
  284.         return(0);
  285.     } else {
  286.         return(1);
  287.     }
  288. }
  289.  
  290. function MetabaseQuerySetCLOB($database, $prepared_query, $parameter, $value, $field)
  291. {
  292.     global $_MDB_databases;
  293.     $result = $_MDB_databases[$database]->setParamClob($prepared_query, $parameter, $value, $field);
  294.     if (MDB::isError($result)) {
  295.         $_MDB_databases[$database]->setError('QuerySetCLOB', $result->getMessage());
  296.         return(0);
  297.     } else {
  298.         return(1);
  299.     }
  300. }
  301.  
  302. function MetabaseQuerySetBLOB($database, $prepared_query, $parameter, $value, $field)
  303. {
  304.     global $_MDB_databases;
  305.     $result = $_MDB_databases[$database]->setParamBlob($prepared_query, $parameter, $value, $field);
  306.     if (MDB::isError($result)) {
  307.         $_MDB_databases[$database]->setError('QuerySetBLOB', $result->getMessage());
  308.         return(0);
  309.     } else {
  310.         return(1);
  311.     }
  312. }
  313.  
  314. function MetabaseQuerySetInteger($database, $prepared_query, $parameter, $value)
  315. {
  316.     global $_MDB_databases;
  317.     $result = $_MDB_databases[$database]->setParamInteger($prepared_query, $parameter, $value);
  318.     if (MDB::isError($result)) {
  319.         $_MDB_databases[$database]->setError('QuerySetInteger', $result->getMessage());
  320.         return(0);
  321.     } else {
  322.         return(1);
  323.     }
  324. }
  325.  
  326. function MetabaseQuerySetBoolean($database, $prepared_query, $parameter, $value)
  327. {
  328.     global $_MDB_databases;
  329.     $result = $_MDB_databases[$database]->setParamBoolean($prepared_query, $parameter, $value);
  330.     if (MDB::isError($result)) {
  331.         $_MDB_databases[$database]->setError('QuerySetBoolean', $result->getMessage());
  332.         return(0);
  333.     } else {
  334.         return(1);
  335.     }
  336. }
  337.  
  338. function MetabaseQuerySetDate($database, $prepared_query, $parameter, $value)
  339. {
  340.     global $_MDB_databases;
  341.     $result = $_MDB_databases[$database]->setParamDate($prepared_query, $parameter, $value);
  342.     if (MDB::isError($result)) {
  343.         $_MDB_databases[$database]->setError('QuerySetDate(', $result->getMessage());
  344.         return(0);
  345.     } else {
  346.         return(1);
  347.     }
  348. }
  349.  
  350. function MetabaseQuerySetTimestamp($database, $prepared_query, $parameter, $value)
  351. {
  352.     global $_MDB_databases;
  353.     $result = $_MDB_databases[$database]->setParamTimestamp($prepared_query, $parameter, $value);
  354.     if (MDB::isError($result)) {
  355.         $_MDB_databases[$database]->setError('QuerySetTimestamp', $result->getMessage());
  356.         return(0);
  357.     } else {
  358.         return(1);
  359.     }
  360. }
  361.  
  362. function MetabaseQuerySetTime($database, $prepared_query, $parameter, $value)
  363. {
  364.     global $_MDB_databases;
  365.     $result = $_MDB_databases[$database]->setParamTime($prepared_query, $parameter, $value);
  366.     if (MDB::isError($result)) {
  367.         $_MDB_databases[$database]->setError('QuerySetTime', $result->getMessage());
  368.         return(0);
  369.     } else {
  370.         return(1);
  371.     }
  372. }
  373.  
  374. function MetabaseQuerySetFloat($database, $prepared_query, $parameter, $value)
  375. {
  376.     global $_MDB_databases;
  377.     $result = $_MDB_databases[$database]->setParamFloat($prepared_query, $parameter, $value);
  378.     if (MDB::isError($result)) {
  379.         $_MDB_databases[$database]->setError('QuerySetFloat', $result->getMessage());
  380.         return(0);
  381.     } else {
  382.         return(1);
  383.     }
  384. }
  385.  
  386. function MetabaseQuerySetDecimal($database, $prepared_query, $parameter, $value)
  387. {
  388.     global $_MDB_databases;
  389.     $result = $_MDB_databases[$database]->setParamDecimal($prepared_query, $parameter, $value);
  390.     if (MDB::isError($result)) {
  391.         $_MDB_databases[$database]->setError('QuerySetDecimal', $result->getMessage());
  392.         return(0);
  393.     } else {
  394.         return(1);
  395.     }
  396. }
  397.  
  398. function MetabaseAffectedRows($database, &$affected_rows)
  399. {
  400.     global $_MDB_databases;
  401.     $result = $_MDB_databases[$database]->affectedRows();
  402.     if (MDB::isError($result)) {
  403.         $_MDB_databases[$database]->setError('AffectedRows', $result->getMessage());
  404.         return(0);
  405.     } else {
  406.         $affected_rows = $result;
  407.         return(1);
  408.     }
  409. }
  410.  
  411. function MetabaseFetchResult($database, $result, $row, $field)
  412. {
  413.     global $_MDB_databases;
  414.     $result = $_MDB_databases[$database]->fetch($result, $row, $field);
  415.     if (MDB::isError($result)) {
  416.         $_MDB_databases[$database]->setError('FetchResult', $result->getMessage());
  417.         return(0);
  418.     } else {
  419.         return($result);
  420.     }
  421. }
  422.  
  423. function MetabaseFetchCLOBResult($database, $result, $row, $field)
  424. {
  425.     global $_MDB_databases;
  426.     $result = $_MDB_databases[$database]->fetchClob($result, $row, $field);
  427.     if (MDB::isError($result)) {
  428.         $_MDB_databases[$database]->setError('FetchCLOBResult', $result->getMessage());
  429.         return(0);
  430.     } else {
  431.         return($result);
  432.     }
  433. }
  434.  
  435. function MetabaseFetchBLOBResult($database, $result, $row, $field)
  436. {
  437.     global $_MDB_databases;
  438.     $result = $_MDB_databases[$database]->fetchBlob($result, $row, $field);
  439.     if (MDB::isError($result)) {
  440.         $_MDB_databases[$database]->setError('FetchBLOBResult', $result->getMessage());
  441.         return(0);
  442.     } else {
  443.         return($result);
  444.     }
  445. }
  446.  
  447. function MetabaseDestroyResultLOB($database, $lob)
  448. {
  449.     global $_MDB_databases;
  450.     $result = $_MDB_databases[$database]->_destroyResultLob($lob);
  451.     if (MDB::isError($result)) {
  452.         $_MDB_databases[$database]->setError('DestroyResultLOB', $result->getMessage());
  453.         return(0);
  454.     } else {
  455.         return(1);
  456.     }
  457. }
  458.  
  459. function MetabaseEndOfResultLOB($database, $lob)
  460. {
  461.     global $_MDB_databases;
  462.     $result = $_MDB_databases[$database]->endOfResultLob($lob);
  463.     if (MDB::isError($result)) {
  464.         $_MDB_databases[$database]->setError('EndOfResultLOB', $result->getMessage());
  465.         return(0);
  466.     } else {
  467.         return($result);
  468.     }
  469. }
  470.  
  471. function MetabaseReadResultLOB($database, $lob, &$data, $length)
  472. {
  473.     global $_MDB_databases;
  474.     $result = $_MDB_databases[$database]->_readResultLob($lob, $data, $length);
  475.     if (MDB::isError($result)) {
  476.         $_MDB_databases[$database]->setError('ReadResultLOB', $result->getMessage());
  477.         return(0);
  478.     } else {
  479.         return(1);
  480.     }
  481. }
  482.  
  483. function MetabaseResultIsNull($database, $result, $row, $field)
  484. {
  485.     global $_MDB_databases;
  486.     $result = $_MDB_databases[$database]->resultIsNull($result, $row, $field);
  487.     if (MDB::isError($result)) {
  488.         $_MDB_databases[$database]->setError('ResultIsNull', $result->getMessage());
  489.         return(0);
  490.     } else {
  491.         return($result);
  492.     }
  493. }
  494.  
  495. function MetabaseFetchDateResult($database, $result, $row, $field)
  496. {
  497.     global $_MDB_databases;
  498.     $result = $_MDB_databases[$database]->fetchDate($result, $row, $field);
  499.     if (MDB::isError($result)) {
  500.         $_MDB_databases[$database]->setError('FetchDateResult', $result->getMessage());
  501.         return(0);
  502.     } else {
  503.         return($result);
  504.     }
  505. }
  506.  
  507. function MetabaseFetchTimestampResult($database, $result, $row, $field)
  508. {
  509.     global $_MDB_databases;
  510.     $result = $_MDB_databases[$database]->fetchTimestamp($result, $row, $field);
  511.     if (MDB::isError($result)) {
  512.         $_MDB_databases[$database]->setError('FetchTimestampResult', $result->getMessage());
  513.         return(0);
  514.     } else {
  515.         return($result);
  516.     }
  517. }
  518.  
  519. function MetabaseFetchTimeResult($database, $result, $row, $field)
  520. {
  521.     global $_MDB_databases;
  522.     $result = $_MDB_databases[$database]->fetchTime($result, $row, $field);
  523.     if (MDB::isError($result)) {
  524.         $_MDB_databases[$database]->setError('FetchTimeResult', $result->getMessage());
  525.         return(0);
  526.     } else {
  527.         return($result);
  528.     }
  529. }
  530.  
  531. function MetabaseFetchBooleanResult($database, $result, $row, $field)
  532. {
  533.     global $_MDB_databases;
  534.     $result = $_MDB_databases[$database]->fetchBoolean($result, $row, $field);
  535.     if (MDB::isError($result)) {
  536.         $_MDB_databases[$database]->setError('FetchBooleanResult', $result->getMessage());
  537.         return(0);
  538.     } else {
  539.         return($result);
  540.     }
  541. }
  542.  
  543. function MetabaseFetchFloatResult($database, $result, $row, $field)
  544. {
  545.     global $_MDB_databases;
  546.     $result = $_MDB_databases[$database]->fetchFloat($result, $row, $field);
  547.     if (MDB::isError($result)) {
  548.         $_MDB_databases[$database]->setError('FetchFloatResult', $result->getMessage());
  549.         return(0);
  550.     } else {
  551.         return($result);
  552.     }
  553. }
  554.  
  555. function MetabaseFetchDecimalResult($database, $result, $row, $field)
  556. {
  557.     global $_MDB_databases;
  558.     $result = $_MDB_databases[$database]->fetchDecimal($result, $row, $field);
  559.     if (MDB::isError($result)) {
  560.         $_MDB_databases[$database]->setError('FetchDecimalResult', $result->getMessage());
  561.         return(0);
  562.     } else {
  563.         return($result);
  564.     }
  565. }
  566.  
  567. function MetabaseFetchResultField($database, $result, &$field)
  568. {
  569.     global $_MDB_databases;
  570.     $result = $_MDB_databases[$database]->fetchOne($result);
  571.     if (MDB::isError($result)) {
  572.         $_MDB_databases[$database]->setError('FetchResultField', $result->getMessage());
  573.         return(0);
  574.     } else {
  575.         $field = $result;
  576.         return(1);
  577.     }
  578. }
  579.  
  580. function MetabaseFetchResultArray($database, $result, &$array, $row)
  581. {
  582.     global $_MDB_databases;
  583.     $result = $_MDB_databases[$database]->fetchInto($result, MDB_FETCHMODE_ORDERED, $row);
  584.     if (MDB::isError($result)) {
  585.         $_MDB_databases[$database]->setError('FetchResultArray', $result->getMessage());
  586.         return(0);
  587.     } else {
  588.         $array = $result;
  589.         return(1);
  590.     }
  591. }
  592.  
  593. function MetabaseFetchResultRow($database, $result, &$row)
  594. {
  595.     global $_MDB_databases;
  596.     $result = $_MDB_databases[$database]->fetchRow($result);
  597.     if (MDB::isError($result)) {
  598.         $_MDB_databases[$database]->setError('FetchResultRow', $result->getMessage());
  599.         return(0);
  600.     } else {
  601.         $row = $result;
  602.         return(1);
  603.     }
  604. }
  605.  
  606. function MetabaseFetchResultColumn($database, $result, &$column)
  607. {
  608.     global $_MDB_databases;
  609.     $result = $_MDB_databases[$database]->fetchCol($result);
  610.     if (MDB::isError($result)) {
  611.         $_MDB_databases[$database]->setError('FetchResultColumn', $result->getMessage());
  612.         return(0);
  613.     } else {
  614.         $column = $result;
  615.         return(1);
  616.     }
  617. }
  618.  
  619. function MetabaseFetchResultAll($database, $result, &$all)
  620. {
  621.     global $_MDB_databases;
  622.     $result = $_MDB_databases[$database]->fetchAll($result);
  623.     if (MDB::isError($result)) {
  624.         $_MDB_databases[$database]->setError('FetchResultAll', $result->getMessage());
  625.         return(0);
  626.     } else {
  627.         $all = $result;
  628.         return(1);
  629.     }
  630. }
  631.  
  632. function MetabaseNumberOfRows($database, $result)
  633. {
  634.     global $_MDB_databases;
  635.     $result = $_MDB_databases[$database]->numRows($result);
  636.     if (MDB::isError($result)) {
  637.         $_MDB_databases[$database]->setError('NumberOfRows', $result->getMessage());
  638.         return(0);
  639.     } else {
  640.        return($result);
  641.     }
  642. }
  643.  
  644. function MetabaseNumberOfColumns($database, $result)
  645. {
  646.     global $_MDB_databases;
  647.     $result = $_MDB_databases[$database]->numCols($result);
  648.     if (MDB::isError($result)) {
  649.         $_MDB_databases[$database]->setError('NumberOfColumns', $result->getMessage());
  650.         return(0);
  651.     } else {
  652.         return($result);
  653.     }
  654. }
  655.  
  656. function MetabaseGetColumnNames($database, $result, &$column_names)
  657. {
  658.     global $_MDB_databases;
  659.     $result = $_MDB_databases[$database]->getColumnNames($result);
  660.     if (MDB::isError($result)) {
  661.         $_MDB_databases[$database]->setError('GetColumnNames', $result->getMessage());
  662.         return(0);
  663.     } else {
  664.         $column_names = $result;
  665.         return(1);
  666.     }
  667. }
  668.  
  669. function MetabaseSetResultTypes($database, $result, &$types)
  670. {
  671.     global $_MDB_databases;
  672.     $result = $_MDB_databases[$database]->setResultTypes($result, $types);
  673.     if (MDB::isError($result)) {
  674.         $_MDB_databases[$database]->setError('SetResultTypes', $result->getMessage());
  675.         return(0);
  676.     } else {
  677.         return(1);
  678.     }
  679. }
  680.  
  681. function MetabaseFreeResult($database, $result)
  682. {
  683.     global $_MDB_databases;
  684.     $result = $_MDB_databases[$database]->freeResult($result);
  685.     if (MDB::isError($result)) {
  686.         $_MDB_databases[$database]->setError('FreeResult', $result->getMessage());
  687.         return(0);
  688.     } else {
  689.         return(1);
  690.     }
  691. }
  692.  
  693. function MetabaseError($database)
  694. {
  695.     global $_MDB_databases;
  696.     $result = $_MDB_databases[$database]->error();
  697.     if (MDB::isError($result)) {
  698.         $_MDB_databases[$database]->setError('Error', $result->getMessage());
  699.         return(0);
  700.     } else {
  701.         return(1);
  702.     }
  703. }
  704.  
  705. function MetabaseSetErrorHandler($database, $function)
  706. {
  707.     global $_MDB_databases;
  708.     $result = $_MDB_databases[$database]->setErrorHandler($function);
  709.     if (MDB::isError($result)) {
  710.         $_MDB_databases[$database]->setError('SetErrorHandler', $result->getMessage());
  711.         return(0);
  712.     } else {
  713.         return(1);
  714.     }
  715. }
  716.  
  717. function MetabaseCreateDatabase($database, $name)
  718. {
  719.     global $_MDB_databases;
  720.     $result = $_MDB_databases[$database]->createDatabase($name);
  721.     if (MDB::isError($result)) {
  722.         $_MDB_databases[$database]->setError('CreateDatabase', $result->getMessage());
  723.         return(0);
  724.     } else {
  725.         return(1);
  726.     }
  727. }
  728.  
  729. function MetabaseDropDatabase($database, $name)
  730. {
  731.     global $_MDB_databases;
  732.     $result = $_MDB_databases[$database]->dropDatabase($name);
  733.     if (MDB::isError($result)) {
  734.         $_MDB_databases[$database]->setError('DropDatabase', $result->getMessage());
  735.         return(0);
  736.     } else {
  737.         return(1);
  738.     }
  739. }
  740.  
  741. function MetabaseSetDatabase($database, $name)
  742. {
  743.     global $_MDB_databases;
  744.     $result = $_MDB_databases[$database]->setDatabase($name);
  745.     if (MDB::isError($result)) {
  746.         $_MDB_databases[$database]->setError('SetDatabase', $result->getMessage());
  747.         return(0);
  748.     } else {
  749.         return($result);
  750.     }
  751. }
  752.  
  753. function MetabaseGetIntegerFieldTypeDeclaration($database, $name, &$field)
  754. {
  755.     global $_MDB_databases;
  756.     $result = $_MDB_databases[$database]->getIntegerDeclaration($name, $field);
  757.     if (MDB::isError($result)) {
  758.         $_MDB_databases[$database]->setError('GetIntegerFieldTypeDeclaration', $result->getMessage());
  759.         return(0);
  760.     } else {
  761.         return(1);
  762.     }
  763. }
  764.  
  765. function MetabaseGetTextFieldTypeDeclaration($database, $name, &$field)
  766. {
  767.     global $_MDB_databases;
  768.     $result = $_MDB_databases[$database]->getTextDeclaration($name, $field);
  769.     if (MDB::isError($result)) {
  770.         $_MDB_databases[$database]->setError('GetTextFieldTypeDeclaration', $result->getMessage());
  771.         return(0);
  772.     } else {
  773.         return(1);
  774.     }
  775. }
  776.  
  777. function MetabaseGetCLOBFieldTypeDeclaration($database, $name, &$field)
  778. {
  779.     global $_MDB_databases;
  780.     $result = $_MDB_databases[$database]->getClobDeclaration($name, $field);
  781.     if (MDB::isError($result)) {
  782.         $_MDB_databases[$database]->setError('GetCLOBFieldTypeDeclaration', $result->getMessage());
  783.         return(0);
  784.     } else {
  785.         return(1);
  786.     }
  787. }
  788.  
  789. function MetabaseGetBLOBFieldTypeDeclaration($database, $name, &$field)
  790. {
  791.     global $_MDB_databases;
  792.     $result = $_MDB_databases[$database]->getBlobDeclaration($name, $field);
  793.     if (MDB::isError($result)) {
  794.         $_MDB_databases[$database]->setError('GetBLOBFieldTypeDeclaration', $result->getMessage());
  795.         return(0);
  796.     } else {
  797.         return(1);
  798.     }
  799. }
  800.  
  801. function MetabaseGetBooleanFieldTypeDeclaration($database, $name, &$field)
  802. {
  803.     global $_MDB_databases;
  804.     $result = $_MDB_databases[$database]->getBooleanDeclaration($name, $field);
  805.     if (MDB::isError($result)) {
  806.         $_MDB_databases[$database]->setError('GetBooleanFieldTypeDeclaration', $result->getMessage());
  807.         return(0);
  808.     } else {
  809.         return(1);
  810.     }
  811. }
  812.  
  813. function MetabaseGetDateFieldTypeDeclaration($database, $name, &$field)
  814. {
  815.     global $_MDB_databases;
  816.     $result = $_MDB_databases[$database]->getDateDeclaration($name, $field);
  817.     if (MDB::isError($result)) {
  818.         $_MDB_databases[$database]->setError('GetDateFieldTypeDeclaration', $result->getMessage());
  819.         return(0);
  820.     } else {
  821.         return(1);
  822.     }
  823. }
  824.  
  825. function MetabaseGetTimestampFieldTypeDeclaration($database, $name, &$field)
  826. {
  827.     global $_MDB_databases;
  828.     $result = $_MDB_databases[$database]->getTimestampDeclaration($name, $field);
  829.     if (MDB::isError($result)) {
  830.         $_MDB_databases[$database]->setError('GetTimestampFieldTypeDeclaration', $result->getMessage());
  831.         return(0);
  832.     } else {
  833.         return(1);
  834.     }
  835. }
  836.  
  837. function MetabaseGetTimeFieldTypeDeclaration($database, $name, &$field)
  838. {
  839.     global $_MDB_databases;
  840.     $result = $_MDB_databases[$database]->getTimeDeclaration($name, $field);
  841.     if (MDB::isError($result)) {
  842.         $_MDB_databases[$database]->setError('GetTimeFieldTypeDeclaration', $result->getMessage());
  843.         return(0);
  844.     } else {
  845.         return(1);
  846.     }
  847. }
  848.  
  849. function MetabaseGetFloatFieldTypeDeclaration($database, $name, &$field)
  850. {
  851.     global $_MDB_databases;
  852.     $result = $_MDB_databases[$database]->getFloatDeclaration($name, $field);
  853.     if (MDB::isError($result)) {
  854.         $_MDB_databases[$database]->setError('GetFloatFieldTypeDeclaration', $result->getMessage());
  855.         return(0);
  856.     } else {
  857.         return(1);
  858.     }
  859. }
  860.  
  861. function MetabaseGetDecimalFieldTypeDeclaration($database, $name, &$field)
  862. {
  863.     global $_MDB_databases;
  864.     $result = $_MDB_databases[$database]->getDecimalDeclaration($name, $field);
  865.     if (MDB::isError($result)) {
  866.         $_MDB_databases[$database]->setError('GetDecimalFieldTypeDeclaration', $result->getMessage());
  867.         return(0);
  868.     } else {
  869.         return(1);
  870.     }
  871. }
  872.  
  873. function MetabaseGetTextFieldValue($database, $value)
  874. {
  875.     global $_MDB_databases;
  876.     $result = $_MDB_databases[$database]->getTextValue($value);
  877.     if (MDB::isError($result)) {
  878.         $_MDB_databases[$database]->setError('GetTextFieldValue', $result->getMessage());
  879.         return(0);
  880.     } else {
  881.         return($result);
  882.     }
  883. }
  884.  
  885. function MetabaseGetBooleanFieldValue($database, $value)
  886. {
  887.     global $_MDB_databases;
  888.     $result = $_MDB_databases[$database]->getBooleanValue($value);
  889.     if (MDB::isError($result)) {
  890.         $_MDB_databases[$database]->setError('GetBooleanFieldValue', $result->getMessage());
  891.         return(0);
  892.     } else {
  893.         return($result);
  894.     }
  895. }
  896.  
  897. function MetabaseGetDateFieldValue($database, $value)
  898. {
  899.     global $_MDB_databases;
  900.     $result = $_MDB_databases[$database]->getDateValue($value);
  901.     if (MDB::isError($result)) {
  902.         $_MDB_databases[$database]->setError('GetDateFieldValue', $result->getMessage());
  903.         return(0);
  904.     } else {
  905.         return($result);
  906.     }
  907. }
  908.  
  909. function MetabaseGetTimestampFieldValue($database, $value)
  910. {
  911.     global $_MDB_databases;
  912.     $result = $_MDB_databases[$database]->getTimestampValue($value);
  913.     if (MDB::isError($result)) {
  914.         $_MDB_databases[$database]->setError('GetTimestampFieldValue', $result->getMessage());
  915.         return(0);
  916.     } else {
  917.         return($result);
  918.     }
  919. }
  920.  
  921. function MetabaseGetTimeFieldValue($database, $value)
  922. {
  923.     global $_MDB_databases;
  924.     $result = $_MDB_databases[$database]->getTimeValue($value);
  925.     if (MDB::isError($result)) {
  926.         $_MDB_databases[$database]->setError('GetTimeFieldValue', $result->getMessage());
  927.         return(0);
  928.     } else {
  929.         return($result);
  930.     }
  931. }
  932.  
  933. function MetabaseGetFloatFieldValue($database, $value)
  934. {
  935.     global $_MDB_databases;
  936.     $result = $_MDB_databases[$database]->getFloatValue($value);
  937.     if (MDB::isError($result)) {
  938.         $_MDB_databases[$database]->setError('GetFloatFieldValue', $result->getMessage());
  939.         return(0);
  940.     } else {
  941.         return($result);
  942.     }
  943. }
  944.  
  945. function MetabaseGetDecimalFieldValue($database, $value)
  946. {
  947.     global $_MDB_databases;
  948.     $result = $_MDB_databases[$database]->getDecimalValue($value);
  949.     if (MDB::isError($result)) {
  950.         $_MDB_databases[$database]->setError('GetDecimalFieldValue', $result->getMessage());
  951.         return(0);
  952.     } else {
  953.         return($result);
  954.     }
  955. }
  956.  
  957. function MetabaseSupport($database, $feature)
  958. {
  959.     global $_MDB_databases;
  960.     $result = $_MDB_databases[$database]->support($feature);
  961.     if (MDB::isError($result)) {
  962.         $_MDB_databases[$database]->setError('Support', $result->getMessage());
  963.         return(0);
  964.     } else {
  965.        return($result);
  966.     }
  967. }
  968.  
  969. function MetabaseCreateTable($database, $name, &$fields)
  970. {
  971.     global $_MDB_databases;
  972.     $result = $_MDB_databases[$database]->createTable($name, $fields);
  973.     if (MDB::isError($result)) {
  974.         $_MDB_databases[$database]->setError('CreateTable', $result->getMessage());
  975.         return(0);
  976.     } else {
  977.         return(1);
  978.     }
  979. }
  980.  
  981. function MetabaseDropTable($database, $name)
  982. {
  983.     global $_MDB_databases;
  984.     $result = $_MDB_databases[$database]->dropTable($name);
  985.     if (MDB::isError($result)) {
  986.         $_MDB_databases[$database]->setError('DropTable', $result->getMessage());
  987.         return(0);
  988.     } else {
  989.         return(1);
  990.     }
  991. }
  992.  
  993. function MetabaseAlterTable($database, $name, &$changes, $check = 0)
  994. {
  995.     global $_MDB_databases;
  996.     $result = $_MDB_databases[$database]->alterTable($name, $changes, $check);
  997.     if (MDB::isError($result)) {
  998.         $_MDB_databases[$database]->setError('AlterTable', $result->getMessage());
  999.         return(0);
  1000.     } else {
  1001.         return(1);
  1002.     }
  1003. }
  1004.  
  1005. function MetabaseListTables($database, &$tables)
  1006. {
  1007.     global $_MDB_databases;
  1008.     $result = $_MDB_databases[$database]->listTables();
  1009.     if (MDB::isError($result)) {
  1010.         $_MDB_databases[$database]->setError('ListTables', $result->getMessage());
  1011.         return(0);
  1012.     } else {
  1013.         $tables = $result;
  1014.         return(1);
  1015.     }
  1016. }
  1017.  
  1018. function MetabaseListTableFields($database, $table, &$fields)
  1019. {
  1020.     global $_MDB_databases;
  1021.     $result = $_MDB_databases[$database]->listTableFields($table);
  1022.     if (MDB::isError($result)) {
  1023.         $_MDB_databases[$database]->setError('ListTableFields', $result->getMessage());
  1024.         return(0);
  1025.     } else {
  1026.         $fields = $result;
  1027.         return(1);
  1028.     }
  1029. }
  1030.  
  1031. function MetabaseGetTableFieldDefinition($database, $table, $field, &$definition)
  1032. {
  1033.     global $_MDB_databases;
  1034.     $result = $_MDB_databases[$database]->getTableFieldDefinition($table, $field);
  1035.     if (MDB::isError($result)) {
  1036.         $_MDB_databases[$database]->setError('GetTableFieldDefinition', $result->getMessage());
  1037.         return(0);
  1038.     } else {
  1039.         $definition = $result[0];
  1040.         return(1);
  1041.     }
  1042. }
  1043.  
  1044. function MetabaseCreateSequence($database, $name, $start)
  1045. {
  1046.     global $_MDB_databases;
  1047.     $result = $_MDB_databases[$database]->createSequence($name, $start);
  1048.     if (MDB::isError($result)) {
  1049.         $_MDB_databases[$database]->setError('CreateSequence', $result->getMessage());
  1050.         return(0);
  1051.     } else {
  1052.         return(1);
  1053.     }
  1054. }
  1055.  
  1056. function MetabaseDropSequence($database, $name)
  1057. {
  1058.     global $_MDB_databases;
  1059.     $result = $_MDB_databases[$database]->dropSequence($name);
  1060.     if (MDB::isError($result)) {
  1061.         $_MDB_databases[$database]->setError('DropSequence', $result->getMessage());
  1062.         return(0);
  1063.     } else {
  1064.         return(1);
  1065.     }
  1066. }
  1067.  
  1068. function MetabaseGetSequenceNextValue($database, $name, &$value)
  1069. {
  1070.     global $_MDB_databases;
  1071.     $result = $_MDB_databases[$database]->nextId($name, FALSE);
  1072.     if (MDB::isError($result)) {
  1073.         $_MDB_databases[$database]->setError('GetSequenceNextValue', $result->getMessage());
  1074.         return(0);
  1075.     } else {
  1076.         $value = $result;
  1077.         return(1);
  1078.     }
  1079. }
  1080.  
  1081. function MetabaseGetSequenceCurrentValue($database, $name, &$value)
  1082. {
  1083.     global $_MDB_databases;
  1084.     $result = $_MDB_databases[$database]->currId($name);
  1085.     if (MDB::isError($result)) {
  1086.         $_MDB_databases[$database]->setError('GetSequenceCurrentValue', $result->getMessage());
  1087.         return(0);
  1088.     } else {
  1089.         $value = $result;
  1090.         return(1);
  1091.     }
  1092. }
  1093.  
  1094. function MetabaseListSequences($database, &$sequences)
  1095. {
  1096.     global $_MDB_databases;
  1097.     $result = $_MDB_databases[$database]->listSequences();
  1098.     if (MDB::isError($result)) {
  1099.         $_MDB_databases[$database]->setError('ListSequences', $result->getMessage());
  1100.         return(0);
  1101.     } else {
  1102.         $sequences = $result;
  1103.         return(1);
  1104.     }
  1105. }
  1106.  
  1107. function MetabaseGetSequenceDefinition($database, $sequence, &$definition)
  1108. {
  1109.     global $_MDB_databases;
  1110.     $result = $_MDB_databases[$database]->getSequenceDefinition($sequence);
  1111.     if (MDB::isError($result)) {
  1112.         $_MDB_databases[$database]->setError('GetSequenceDefinition', $result->getMessage());
  1113.         return(0);
  1114.     } else {
  1115.         $definition = $result;
  1116.         return(1);
  1117.     }
  1118. }
  1119.  
  1120. function MetabaseAutoCommitTransactions($database, $auto_commit)
  1121. {
  1122.     global $_MDB_databases;
  1123.     $result = $_MDB_databases[$database]->autoCommit($auto_commit);
  1124.     if (MDB::isError($result)) {
  1125.         $_MDB_databases[$database]->setError('AutoCommitTransactions', $result->getMessage());
  1126.         return(0);
  1127.     } else {
  1128.         return(1);
  1129.     }
  1130. }
  1131.  
  1132. function MetabaseCommitTransaction($database)
  1133. {
  1134.     global $_MDB_databases;
  1135.     $result = $_MDB_databases[$database]->commit();
  1136.     if (MDB::isError($result)) {
  1137.         $_MDB_databases[$database]->setError('CommitTransaction', $result->getMessage());
  1138.         return(0);
  1139.     } else {
  1140.         return(1);
  1141.     }
  1142. }
  1143.  
  1144. function MetabaseRollbackTransaction($database)
  1145. {
  1146.     global $_MDB_databases;
  1147.     $result = $_MDB_databases[$database]->rollback();
  1148.     if (MDB::isError($result)) {
  1149.         $_MDB_databases[$database]->setError('RollbackTransaction', $result->getMessage());
  1150.         return(0);
  1151.     } else {
  1152.         return($result);
  1153.     }
  1154. }
  1155.  
  1156. function MetabaseCreateIndex($database, $table, $name, $definition)
  1157. {
  1158.     global $_MDB_databases;
  1159.     $result = $_MDB_databases[$database]->createIndex($table, $name, $definition);
  1160.     if (MDB::isError($result)) {
  1161.         $_MDB_databases[$database]->setError('CreateIndex', $result->getMessage());
  1162.         return(0);
  1163.     } else {
  1164.         return(1);
  1165.     }
  1166. }
  1167.  
  1168. function MetabaseDropIndex($database, $table, $name)
  1169. {
  1170.     global $_MDB_databases;
  1171.     $result = $_MDB_databases[$database]->dropIndex($table, $name);
  1172.     if (MDB::isError($result)) {
  1173.         $_MDB_databases[$database]->setError('DropIndex', $result->getMessage());
  1174.         return(0);
  1175.     } else {
  1176.         return(1);
  1177.     }
  1178. }
  1179.  
  1180. function MetabaseListTableIndex($database, $table, &$index)
  1181. {
  1182.     global $_MDB_databases;
  1183.     $result = $_MDB_databases[$database]->listTableIndex($table);
  1184.     if (MDB::isError($result)) {
  1185.         $_MDB_databases[$database]->setError('ListTableIndex', $result->getMessage());
  1186.         return(0);
  1187.     } else {
  1188.         $index = $result;
  1189.         return(1);
  1190.     }
  1191. }
  1192.  
  1193. function MetabaseGetTableIndexDefinition($database, $table, $index, &$definition)
  1194. {
  1195.     global $_MDB_databases;
  1196.     $result = $_MDB_databases[$database]->getTableIndexDefinition($table, $index);
  1197.     if (MDB::isError($result)) {
  1198.         $_MDB_databases[$database]->setError('GetTableIndexDefinition', $result->getMessage());
  1199.         return(0);
  1200.     } else {
  1201.         $definition = $result;
  1202.         return(1);
  1203.     }
  1204. }
  1205.  
  1206. function MetabaseNow()
  1207. {
  1208.     return(MDB_Date::mdbNow());
  1209. }
  1210.  
  1211. function MetabaseToday()
  1212. {
  1213.     return(MDB_Date::mdbToday());
  1214. }
  1215.  
  1216. function MetabaseTime()
  1217. {
  1218.     return(MDB_Date::mdbTime());
  1219. }
  1220.  
  1221. function MetabaseSetSelectedRowRange($database, $first, $limit)
  1222. {
  1223.     global $_MDB_databases;
  1224.     $result = $_MDB_databases[$database]->setSelectedRowRange($first, $limit);
  1225.     if (MDB::isError($result)) {
  1226.         $_MDB_databases[$database]->setError('SetSelectedRowRange', $result->getMessage());
  1227.         return(0);
  1228.     } else {
  1229.         return(1);
  1230.     }
  1231. }
  1232.  
  1233. function MetabaseEndOfResult($database, $result)
  1234. {
  1235.     global $_MDB_databases;
  1236.     $result = $_MDB_databases[$database]->endOfResult($result);
  1237.     if (MDB::isError($result)) {
  1238.         $_MDB_databases[$database]->setError('EndOfResult', $result->getMessage());
  1239.         return(0);
  1240.     } else {
  1241.        return($result);
  1242.     }
  1243. }
  1244.  
  1245. function MetabaseCaptureDebugOutput($database, $capture)
  1246. {
  1247.     global $_MDB_databases;
  1248.     $result = $_MDB_databases[$database]->captureDebugOutput($capture);
  1249.     if (MDB::isError($result)) {
  1250.         $_MDB_databases[$database]->setError('CaptureDebugOutput', $result->getMessage());
  1251.         return(0);
  1252.     } else {
  1253.         return(1);
  1254.     }
  1255. }
  1256.  
  1257. function MetabaseDebugOutput($database)
  1258. {
  1259.     global $_MDB_databases;
  1260.     $result = $_MDB_databases[$database]->debugOutput();
  1261.     if (MDB::isError($result)) {
  1262.         $_MDB_databases[$database]->setError('DebugOutput', $result->getMessage());
  1263.         return(0);
  1264.     } else {
  1265.         return($result);
  1266.     }
  1267. }
  1268.  
  1269. function MetabaseDebug($database, $message)
  1270. {
  1271.     global $_MDB_databases;
  1272.     $result = $_MDB_databases[$database]->debug($message);
  1273.     if (MDB::isError($result)) {
  1274.         $_MDB_databases[$database]->setError('Debug', $result->getMessage());
  1275.         return(0);
  1276.     } else {
  1277.         return(1);
  1278.     }
  1279. }
  1280.  
  1281. function MetabaseShutdownTransactions()
  1282. {
  1283.     _shutdownTransactions();
  1284. }
  1285.  
  1286. function MetabaseDefaultDebugOutput($database, $message)
  1287. {
  1288.     global $_MDB_databases;
  1289.     $result = $_MDB_databases[$database]->defaultDebugOutput($_MDB_databases[$database], $message);
  1290.     if (MDB::isError($result)) {
  1291.         $_MDB_databases[$database]->setError('DefaultDebugOutput', $result->getMessage());
  1292.         return(0);
  1293.     } else {
  1294.         return(1);
  1295.     }
  1296. }
  1297.  
  1298. function MetabaseCreateLOB(&$arguments, &$lob)
  1299. {
  1300.     global $_MDB_databases;
  1301.     $args = $arguments;
  1302.     $args['Database'] = $_MDB_databases[$arguments['Database']];
  1303.     $result = $_MDB_databases[$arguments['Database']]->createLob($args);
  1304.     $args['Database'] = $arguments['Database']
  1305.     ;
  1306.     if (MDB::isError($result)) {
  1307.         global $lob_error;
  1308.         $lob_error = $result->getMessage();
  1309.         return(0);
  1310.     } else {
  1311.         $lob = $result;
  1312.         return(1);
  1313.     }
  1314. }
  1315.  
  1316. function MetabaseDestroyLOB($lob)
  1317. {
  1318.     global $_MDB_lobs;
  1319.     $result = $_MDB_lobs[$lob]->database->destroyLob($lob);
  1320.     if (MDB::isError($result)) {
  1321.         global $lob_error;
  1322.         $lob_error = $result->getMessage();
  1323.         return(0);
  1324.     } else {
  1325.         return(1);
  1326.     }
  1327. }
  1328.  
  1329. function MetabaseEndOfLOB($lob)
  1330. {
  1331.     global $_MDB_lobs;
  1332.     $result = $_MDB_lobs[$lob]->database->endOfLob($lob);
  1333.     if (MDB::isError($result)) {
  1334.         global $lob_error;
  1335.         $lob_error = $result->getMessage();
  1336.         return(0);
  1337.     } else {
  1338.         return($result);
  1339.     }
  1340. }
  1341.  
  1342. function MetabaseReadLOB($lob, &$data, $length)
  1343. {
  1344.     global $_MDB_lobs;
  1345.     $result = $_MDB_lobs[$lob]->database->readLob($lob, $data, $length);
  1346.     if (MDB::isError($result)) {
  1347.         global $lob_error;
  1348.         $lob_error = $result->getMessage();
  1349.         return(0);
  1350.     } else {
  1351.         return($result);
  1352.     }
  1353. }
  1354.  
  1355. function MetabaseLOBError($lob)
  1356. {
  1357.     global $lob_error;
  1358.     return($lob_error);
  1359. }
  1360.  
  1361. class metabase_manager_class
  1362. {
  1363.     var $MDB_manager_object;
  1364.  
  1365.     var $fail_on_invalid_names = 1;
  1366.     var $error = '';
  1367.     var $warnings = array();
  1368.     var $database = 0;
  1369.     var $database_definition = array(
  1370.         'name' => '',
  1371.         'create' => 0,
  1372.         'TABLES' => array()
  1373.     );
  1374.  
  1375.     function metabase_manager_class()
  1376.     {
  1377.         $this->MDB_manager_object =& new MDB_Manager;
  1378.         $this->MDB_manager_object->fail_on_invalid_names =& $this->fail_on_invalid_names;
  1379.         $this->MDB_manager_object->error =& $this->error;
  1380.         $this->MDB_manager_object->warnings =& $this->warnings;
  1381.         $this->MDB_manager_object->database_definition =& $this->database_definition;
  1382.     }
  1383.  
  1384.     function SetupDatabase(&$arguments)
  1385.     {
  1386.         _convertArguments($arguments, $dsninfo, $options);
  1387.  
  1388.         $result = $this->MDB_manager_object->connect($dsninfo, $options);
  1389.         if (MDB::isError($result)) {
  1390.             return($result->getMessage());
  1391.         }
  1392.         $this->database = $this->MDB_manager_object->database->database;
  1393.         return(1);
  1394.     }
  1395.  
  1396.     function CloseSetup()
  1397.     {
  1398.         $result = $this->MDB_manager_object->disconnect();
  1399.         if (MDB::isError($result)) {
  1400.             return(0);
  1401.         } else {
  1402.             return(1);
  1403.         }
  1404.     }
  1405.  
  1406.     function GetField(&$field, $field_name, $declaration, &$query)
  1407.     {
  1408.         if($declaration) {
  1409.             $result = $this->MDB_manager_object->database->getFieldDeclaration($field, $field_name, $declaration);
  1410.         } else {
  1411.             $result = $field_name;
  1412.         }
  1413.         if (MDB::isError($result)) {
  1414.             return(0);
  1415.         } else {
  1416.             $query = $result;
  1417.             return(1);
  1418.         }
  1419.     }
  1420.  
  1421.     function GetFieldList($fields, $declaration, &$query_fields)
  1422.     {
  1423.         if($declaration) {
  1424.             $result = $this->MDB_manager_object->database->getFieldDeclarationList($fields);
  1425.         } else {
  1426.             for(reset($fields), $i = 0;
  1427.                 $field_number < count($fields);
  1428.                 $i++, next($fields))
  1429.             {
  1430.                 if ($i > 0) {
  1431.                     $query_fields .= ', ';
  1432.                 }
  1433.                 $result .= key($fields);
  1434.             }
  1435.         }
  1436.         if (MDB::isError($result)) {
  1437.             return(0);
  1438.         } else {
  1439.             $query_fields = $result;
  1440.             return(1);
  1441.         }
  1442.     }
  1443.  
  1444.     function GetFields($table, &$fields)
  1445.     {
  1446.         $result = $this->MDB_manager_object->database->getFieldDeclarationList($this->database_definition['TABLES'][$table]['FIELDS']);
  1447.         if (MDB::isError($result)) {
  1448.             return(0);
  1449.         } else {
  1450.             $fields = $result;
  1451.             return(1);
  1452.         }
  1453.     }
  1454.  
  1455.     function CreateTable($table_name, $table)
  1456.     {
  1457.         $result = $this->MDB_manager_object->_createTable($table_name, $table);
  1458.         if (MDB::isError($result)) {
  1459.             return(0);
  1460.         } else {
  1461.             return(1);
  1462.         }
  1463.     }
  1464.  
  1465.     function DropTable($table_name)
  1466.     {
  1467.         $result = $this->MDB_manager_object->_dropTable($table_name);
  1468.         if (MDB::isError($result)) {
  1469.             return(0);
  1470.         } else {
  1471.             return(1);
  1472.         }
  1473.     }
  1474.  
  1475.     function CreateSequence($sequence_name, $sequence, $created_on_table)
  1476.     {
  1477.         $result = $this->MDB_manager_object->createSequence($sequence_name, $sequence, $created_on_table);
  1478.         if (MDB::isError($result)) {
  1479.             return(0);
  1480.         } else {
  1481.             return(1);
  1482.         }
  1483.     }
  1484.  
  1485.     function DropSequence($sequence_name)
  1486.     {
  1487.         $result = $this->MDB_manager_object->_dropSequence($sequence_name);
  1488.         if (MDB::isError($result)) {
  1489.             return(0);
  1490.         } else {
  1491.             return(1);
  1492.         }
  1493.     }
  1494.  
  1495.     function CreateDatabase()
  1496.     {
  1497.         $result = $this->MDB_manager_object->_createDatabase();
  1498.         if (MDB::isError($result)) {
  1499.             return(0);
  1500.         } else {
  1501.             return(1);
  1502.         }
  1503.     }
  1504.  
  1505.     function AddDefinitionChange(&$changes, $definition, $item, $change)
  1506.     {
  1507.         $result = $this->MDB_manager_object->_addDefinitionChange($changes, $definition, $item, $change);
  1508.         if (MDB::isError($result)) {
  1509.             return(0);
  1510.         } else {
  1511.             return(1);
  1512.         }
  1513.     }
  1514.  
  1515.     function CompareDefinitions(&$previous_definition, &$changes)
  1516.     {
  1517.         $result = $this->MDB_manager_object->_compareDefinitions($previous_definition);
  1518.         if (MDB::isError($result)) {
  1519.             return(0);
  1520.         } else {
  1521.             $changes = $result;
  1522.             return(1);
  1523.         }
  1524.     }
  1525.  
  1526.     function AlterDatabase(&$previous_definition, &$changes)
  1527.     {
  1528.         $result = $this->MDB_manager_object->_alterDatabase($previous_definition, $changes);
  1529.         if (MDB::isError($result)) {
  1530.             return(0);
  1531.         } else {
  1532.             return(1);
  1533.         }
  1534.     }
  1535.  
  1536.     function EscapeSpecialCharacters($string)
  1537.     {
  1538.         $result = $this->MDB_manager_object->_escapeSpecialCharacters($string);
  1539.         if (MDB::isError($result)) {
  1540.             return(0);
  1541.         } else {
  1542.             return($result);
  1543.         }
  1544.     }
  1545.  
  1546.     function DumpSequence($sequence_name, $output, $eol, $dump_definition)
  1547.     {
  1548.         $result = $this->MDB_manager_object->_dumpSequence($sequence_name, $output, $eol, $dump_definition);
  1549.         if (MDB::isError($result)) {
  1550.             return(0);
  1551.         } else {
  1552.             return(1);
  1553.         }
  1554.     }
  1555.  
  1556.     function DumpDatabase($arguments)
  1557.     {
  1558.         $result = $this->MDB_manager_object->dumpDatabase($arguments);
  1559.         if (MDB::isError($result)) {
  1560.             return(0);
  1561.         } else {
  1562.             return(1);
  1563.         }
  1564.     }
  1565.  
  1566.     function ParseDatabaseDefinitionFile($input_file, &$database_definition, &$variables, $fail_on_invalid_names = 1)
  1567.     {
  1568.         $result = $this->MDB_manager_object->parseDatabaseDefinitionFile($input_file, $variables, $fail_on_invalid_names);
  1569.         if (MDB::isError($result)) {
  1570.             return(0);
  1571.         } else {
  1572.             $database_definition = $result;
  1573.             return(1);
  1574.         }
  1575.     }
  1576.  
  1577.     function DumpDatabaseChanges(&$changes)
  1578.     {
  1579.         $result = $this->MDB_manager_object->_debugDatabaseChanges($changes);
  1580.         if (MDB::isError($result)) {
  1581.             return(0);
  1582.         } else {
  1583.             return(1);
  1584.         }
  1585.     }
  1586.  
  1587.     function UpdateDatabase($current_schema_file, $previous_schema_file, &$arguments, &$variables)
  1588.     {
  1589.         _convertArguments($arguments, $dsninfo, $options);
  1590.  
  1591.         $result = $this->MDB_manager_object->connect($dsninfo, $options);
  1592.         if (MDB::isError($result)) {
  1593.             return($result);
  1594.         }
  1595.  
  1596.         $result = $this->MDB_manager_object->updateDatabase($current_schema_file, $previous_schema_file, $variables);
  1597.         if (MDB::isError($result)) {
  1598.             return($result->getMessage());
  1599.         }
  1600.         $this->database = $this->MDB_manager_object->database->database;
  1601.         return(1);
  1602.     }
  1603.  
  1604.     function DumpDatabaseContents($schema_file, &$setup_arguments, &$dump_arguments, &$variables)
  1605.     {
  1606.         $result = $this->MDB_manager_object->_dumpDatabaseContents($schema_file, $setup_arguments, $dump_arguments, $variables);
  1607.         if (MDB::isError($result)) {
  1608.             return(0);
  1609.         } else {
  1610.             $database_definition = $result;
  1611.             return($result);
  1612.         }
  1613.     }
  1614.  
  1615.     function GetDefinitionFromDatabase()
  1616.     {
  1617.         $result = $this->MDB_manager_object->getDefinitionFromDatabase();
  1618.         if (MDB::isError($result)) {
  1619.             return(0);
  1620.         } else {
  1621.             return(1);
  1622.         }
  1623.     }
  1624. };
  1625. ?>
  1626.